package com.parallel;
/**
 *
 **/

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.text.DecimalFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.groupingBy;

/**
 * @Author weiwei
 * @Date 2021-03-04 10:42
 * @description
 **/
@Slf4j
public class StreamUseThink {


    /**
     * - 通过 stream 方法把 List 或数组转换为流；
     * - 通过 Stream.of 方法直接传入多个元素构成一个流；
     * - 通过 Stream.iterate 方法使用迭代的方式构造一个无限流，然后使用 limit 限制流元素个数；
     * - 通过 Stream.generate 方法从外部传入一个提供元素的 Supplier 来构造无限流，然后使用 limit 限制流元素个数；
     * - 通过 IntStream 或 DoubleStream 构造基本类型的流。
     */
    @Test
    @SuppressWarnings("all")
    public void createStream(){
        DecimalFormat df = new DecimalFormat("#0.00");
        Arrays.asList("a1","a2","a3").stream().forEach(System.out::println);
        Arrays.stream(new String[]{"a1","a2","a3"}).forEach(System.out::println);

        Stream.of("b1","b2","b3").forEach(System.out::println);
        //对初始值操作
        Stream.iterate(2,i-> i * 2).limit(10).forEach(System.out::println);
        //直接函数获取
        Stream.generate(()->df.format(Math.random()+1)).limit(10).forEach(System.out::println);

        IntStream.range(1, 3).forEach(System.out::println);
        //各种转换，后面注释代表了输出结果
        //boxed 作用使IntStream变成一个strame<Integet>
        System.out.println(IntStream.of(1, 2).toArray().getClass()); //class [I
        System.out.println(Stream.of(1, 2).mapToInt(Integer::intValue).toArray().getClass()); //class [I
        System.out.println(IntStream.of(1, 2).boxed().toArray().getClass()); //class [Ljava.lang.Object;
        System.out.println(IntStream.of(1, 2).asDoubleStream().toArray().getClass()); //class [D
        System.out.println(IntStream.of(1, 2).asLongStream().toArray().getClass()); //class [J


        Arrays.asList("a", "b", "c").stream()  // Stream<String>
                .mapToInt(String::length)       // IntStream
                .asLongStream()                 // LongStream
                .mapToDouble(x -> x / 10.0)     // DoubleStream
                .boxed()                        // Stream<Double>
                .mapToLong(x -> 1L)             // LongStream
                .mapToObj(x -> "")              // Stream<String>
                .collect(Collectors.toList());

    }


   public void group(){
       //按照用户名分组，统计下单数量
//       System.out.println(orders.stream().collect(groupingBy(Order::getCustomerName, counting()))
//               .entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).collect(toList()));
//
//       //按照用户名分组，统计订单总金额
//       System.out.println(orders.stream().collect(groupingBy(Order::getCustomerName, summingDouble(Order::getTotalPrice)))
//               .entrySet().stream().sorted(Map.Entry.<String, Double>comparingByValue().reversed()).collect(toList()));
//
//       //按照用户名分组，统计商品采购数量
//       System.out.println(orders.stream().collect(groupingBy(Order::getCustomerName,
//               summingInt(order -> order.getOrderItemList().stream()
//                       .collect(summingInt(OrderItem::getProductQuantity)))))
//               .entrySet().stream().sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).collect(toList()));
//
//       //统计最受欢迎的商品，倒序后取第一个
//       orders.stream()
//               .flatMap(order -> order.getOrderItemList().stream())
//               .collect(groupingBy(OrderItem::getProductName, summingInt(OrderItem::getProductQuantity)))
//               .entrySet().stream()
//               .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
//               .map(Map.Entry::getKey)
//               .findFirst()
//               .ifPresent(System.out::println);
//
//       //统计最受欢迎的商品的另一种方式，直接利用maxBy
//       orders.stream()
//               .flatMap(order -> order.getOrderItemList().stream())
//               .collect(groupingBy(OrderItem::getProductName, summingInt(OrderItem::getProductQuantity)))
//               .entrySet().stream()
//               .collect(maxBy(Map.Entry.comparingByValue()))
//               .map(Map.Entry::getKey)
//               .ifPresent(System.out::println);
//
//       //按照用户名分组，选用户下的总金额最大的订单
//       orders.stream().collect(groupingBy(Order::getCustomerName, collectingAndThen(maxBy(comparingDouble(Order::getTotalPrice)), Optional::get)))
//               .forEach((k, v) -> System.out.println(k + "#" + v.getTotalPrice() + "@" + v.getPlacedAt()));
//
//       //根据下单年月分组，统计订单ID列表
//       System.out.println(orders.stream().collect
//               (groupingBy(order -> order.getPlacedAt().format(DateTimeFormatter.ofPattern("yyyyMM")),
//                       mapping(order -> order.getId(), toList()))));
//
//       //根据下单年月+用户名两次分组，统计订单ID列表
//       System.out.println(orders.stream().collect
//               (groupingBy(order -> order.getPlacedAt().format(DateTimeFormatter.ofPattern("yyyyMM")),
//                       groupingBy(order -> order.getCustomerName(),
//                               mapping(order -> order.getId(), toList())))));
   }



}
